package com.future.service.Impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.future.domain.DTO.PermissionDTO;
import com.future.domain.Permission;
import com.future.domain.Result;
import com.future.domain.Tag;
import com.future.mapper.TagMapper;
import com.future.service.TagService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class TagServiceImpl extends ServiceImpl<TagMapper, Tag> implements TagService {
    @Autowired
    private TagMapper tagMapper;
    @Override
    @Transactional
    public Result saveTag(String name) {
        // 1. 校验：名称非空
        if (name == null || name.trim().isEmpty()) {
            return Result.fail("标签名称不能为空");
        }

        // 2. 查重：避免重复标签
        QueryWrapper<Tag> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", name.trim()); // trim 处理空格
        Tag existTag = tagMapper.selectOne(queryWrapper);
        if (existTag != null) {
            return Result.fail("标签已存在");
        }

        // 3. 构建实体类，设置默认值
        Tag tag = new Tag();

        tag.setName(name.trim());
        tag.setCreatedAt(LocalDateTime.now()); // 后端生成时间

        // 4. 保存到数据库
        try {
            int rows = tagMapper.insert(tag);
            if (rows > 0) {
                // 插入成功后，id已被数据库自动生成并回填
                Long generatedId = tag.getId();
                return Result.ok("标签保存成功，id为：" + generatedId);
            }
            return Result.fail("标签保存失败，原因：数据库插入失败");
        } catch (Exception e) {
            return Result.fail("标签保存失败，原因：" + e.getMessage());
        }


    }

    @Override
    public Long selectTagIdByName(String name) {
        QueryWrapper<Tag> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", name);
        Tag tag = tagMapper.selectOne(queryWrapper);
        if (tag != null) {
            return tag.getId();
        }
        return null;
    }
    @Override
    public List<Long> selectTagIdsByNames(List<String> tagNames) {
        // 1. 构建查询条件：精确匹配标签名称
        QueryWrapper<Tag> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("name", tagNames);  // 按名称精确查询

        // 2. 执行查询，获取标签列表
        List<Tag> tags = tagMapper.selectList(queryWrapper);

        // 3. 转换为ID列表（避免返回null，若无结果返回空列表）
        if (tags == null || tags.isEmpty()) {
            return new ArrayList<>();  // 返回空列表而非null，便于前端处理
        }

        // 4. 提取每个标签的ID并返回
        return tags.stream()
                .map(Tag::getId)    // 提取id字段
                .collect(Collectors.toList());
    }

    @Override
    public Result selectByPage(Integer pageNum, Integer pageSize) {
        IPage<Tag> page = new Page<>(pageNum, pageSize);
        IPage<Tag> tagPage = this.page(page);
        return Result.ok(tagPage);
    }

    @Override
    @Transactional
    public Result deleteTag(Long id) {
        // 1. 校验ID合法性
        if (id == null || id <= 0) {
            return Result.fail("标签ID无效");
        }

        // 2. 检查标签是否存在
        Tag existTag = tagMapper.selectById(id);
        if (existTag == null) {
            return Result.fail("标签不存在或已被删除");
        }

        // 3. 执行删除操作
        try {
            int rows = tagMapper.deleteById(id);
            if (rows > 0) {
                return Result.ok("标签删除成功");
            }
            return Result.fail("标签删除失败，数据库操作无影响");
        } catch (Exception e) {
            return Result.fail("标签删除失败：" + e.getMessage());
        }
    }

    @Override
    @Transactional
    public Result updateTag(Tag tag) {
        // 1. 校验参数合法性
        if (tag == null || tag.getId() == null || tag.getId() <= 0) {
            return Result.fail("标签ID不能为空");
        }
        if (tag.getName() == null || tag.getName().trim().isEmpty()) {
            return Result.fail("标签名称不能为空");
        }

        // 2. 检查标签是否存在
        Tag existTag = tagMapper.selectById(tag.getId());
        if (existTag == null) {
            return Result.fail("标签不存在或已被删除");
        }

        // 3. 处理标签名称（去重校验，排除自身）
        String newName = tag.getName().trim();
        QueryWrapper<Tag> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", newName)
                .ne("id", tag.getId()); // 排除当前标签ID
        Tag duplicateTag = tagMapper.selectOne(queryWrapper);
        if (duplicateTag != null) {
            return Result.fail("标签名称已存在，请更换名称");
        }

        // 4. 更新标签信息
        try {
            existTag.setName(newName);
            existTag.setCreatedAt(LocalDateTime.now()); // 更新时间戳
            int rows = tagMapper.updateById(existTag);
            if (rows > 0) {
                return Result.ok("标签更新成功");
            }
            return Result.fail("标签更新失败，数据库操作无影响");
        } catch (Exception e) {
            return Result.fail("标签更新失败：" + e.getMessage());
        }
    }

    @Override
    public Result selectTagById(Long tagId) {
        // 1. 校验ID合法性
        if (tagId == null || tagId <= 0) {
            return Result.fail("标签ID无效");
        }

        // 2. 查询标签信息
        Tag tag = tagMapper.selectById(tagId);
        if (tag == null) {
            return Result.fail("标签不存在");
        }

        // 3. 返回标签信息
        return Result.ok(tag);
    }

    @Override
    public Result selectTagNameByIds(List<Long> tagIds) {
        // 1. 校验参数合法性
        if (tagIds == null || tagIds.isEmpty()) {
            return Result.fail("标签ID列表不能为空");
        }

        // 2. 批量查询标签
        QueryWrapper<Tag> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("id", tagIds);
        List<Tag> tags = tagMapper.selectList(queryWrapper);

        // 3. 提取标签名称（保持与输入ID列表顺序一致）
        List<String> tagNames = new ArrayList<>(tagIds.size());
        for (Long id : tagIds) {
            // 查找对应ID的标签名称，不存在则用null或空字符串占位
            String name = tags.stream()
                    .filter(tag -> id.equals(tag.getId()))
                    .map(Tag::getName)
                    .findFirst()
                    .orElse(null);
            tagNames.add(name);
        }

        // 4. 返回结果
        return Result.ok(tagNames);
    }

}
